package com.audaque.springboot.foshanupload.core.util;

import java.lang.reflect.Array;

/**
 * 首选java.util.Arrays
 */
public class ArrayUtils {
    /**
     * 数组遍历打印{*******}
     */
    public static void arrayPrint(int[] arr) {
        String temp = "[";
        for (int i = 0; i <= arr.length - 1; i++) {
            temp += arr[i];
            if (i == arr.length - 1)
                temp += "]";
            else temp += ",";
        }
        System.out.println(temp);
    }



    /**
     * 遍历二维数组
     */
    public static void array2Print(int[][] arr) {
        String temp = "[";
        for (int i = 0; i < arr.length; i++) {
            temp += "[";
            for (int j = 0; j < arr[i].length; j++) {
                temp += arr[i][j];
                if (j == arr[i].length - 1)
                    temp += "]";
                else
                    temp += ",";
            }
            if (i == arr.length - 1)
                temp += "]";
            else
                temp += ",";
        }
        System.out.println(temp);
    }

    /**
     * 复制数组中的一段元素到另一个数组进行覆盖
     */
    public static void arrayCope(int[] src, int srcPos, int[] dest, int destPos, int length) {
        System.out.println("srcPos=" + srcPos + ",destPos=" + destPos + "length=" + length);
        if (srcPos < 0 || destPos < 0 || length < 0 || srcPos + length > src.length) {
            System.out.println("参数超出方法的应用范围");
        }
        for (int index = srcPos; index < srcPos + length; index++) {
            dest[destPos] = src[index];
            destPos++;
        }
    }
    public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length) {
        if (src == null || dest == null) {
            throw new NullPointerException("源数组和目标数组都不能为null");
        }
        if (!src.getClass().isArray() || !dest.getClass().isArray()) {
            throw new ArrayStoreException("源和目标必须都是数组！");
        }
        if (srcPos < 0 || destPos < 0 || length < 0 ||
                srcPos + length > Array.getLength(src) || destPos + length > Array.getLength(dest)) {
            throw new IndexOutOfBoundsException("源和目标元素类型必须相同！");
        }
        for (int index = srcPos; index < srcPos + length; index++) {
            //获取需要拷贝的元素
            Object val = Array.get(src, index);
            //给目标设置元素
            Array.set(dest, destPos, val);
            destPos++;
        }
    }

    /**
     * 交换数组中的两个元素
     */
    //用索引来传递数组元素
    public static void swapTwoArrayInt(int[] arr, int a, int b) {
        int temp = 0;
        temp = arr[a];
        arr[a] = arr[b];
        arr[b] = temp;
    }
	/*不能用数组元素传递
	public static void swapTwoInt1(int a,int b)
	{
		int temp=0;
		temp=a;
		a=b;
		b=temp;
	}*/

    /**
     * 数组的直接选择排序(从左向右地逐个跟其他元素比较遍,从左向右地得出结果)
     */
    public static void arrayDirectSelectSort(int[] arr) {
        for (int i = 0; i <= arr.length - 2; i++) {
            for (int j = i + 1; j <= arr.length - 1; j++) {
                if (arr[i] > arr[j])
                    //不能用数组元素传递
                    //swapTwoInt1((int) arr[i],(int)arr[j]);
                    swapTwoArrayInt(arr, i, j);//用索引来传递数组元素
            }
        }
        arrayPrint(arr);
    }

    /**
     * 数组的冒泡排序(从左向右地相邻两两比较,从右向左地得出结果)
     */
    public static void arrayMaopaoSelectSort(int[] arr) {
        for (int i = 0; i <= arr.length - 1; i++) {
            for (int j = 0; j <= arr.length - 2 - i; j++) {
                if (arr[j] > arr[j + 1])
                    //不能用数组元素传递
                    //swapTwoInt1((int) arr[i],(int)arr[j]);
                    swapTwoArrayInt(arr, j, j + 1);//用索引来传递数组元素
            }
        }
        arrayPrint(arr);
    }

    /**
     * 折半查找法
     */
    public static void arrayBinarySearch(int[] arr, int target) {
        //定义三个变量记录查找范围的最大、最小、中间索引值
        int max = arr.length - 1;
        int min = 0;
        while (true) {
            int mid = (max + min) >> 1;
            if (target > arr[mid])
                min = mid + 1;
            else if (target < arr[mid])
                max = mid - 1;
            else {
                System.out.println("索引值：" + mid);//找到的情况
                break;
            }
            if (min > max) {
                System.out.println("找不到的");
                break;
            }
        }
    }

    /**
     * 清除数组的重复元素
     */
    public static void clearRepeat(int[] oldArr) {
        int count = 0; //count变量 是用于记录重复元素的个数
        //计算出重复元素的个数
        for (int i = 0; i < oldArr.length - 1; i++) {
            for (int j = i + 1; j < oldArr.length; j++) {
                if (oldArr[i] == oldArr[j]) {
                    count++;
                    break;
                }
            }
        }
        if (count != oldArr.length) {
            //创建一个新的数组
            int[] newArr = new int[oldArr.length - count];
            int index = 0;    //新数组使用的索引值。
            //遍历旧数组
            for (int i = 0; i < oldArr.length; i++) {
                boolean flag = false; //该标识是用于标识取出的元素是否存在新数组中。 false默认情况是不存在 的。
                int temp = oldArr[i];    //从旧数组 中取出遍历的元素
                //遍历新的数组是否存在该数据,新数组默认为赋0
                for (int j = 0; j < newArr.length; j++) {
                    if (newArr[j] == temp) {
                        flag = true;
                        break;
                    }
                }
                //该元素不存在新数组中，这时候应该存储起来
                if (flag == false) {
                    newArr[index++] = temp;
                }
            }
            arrayPrint(newArr);
        }
    }













}
